package com.flashline.registry.openapi.service.v300;

public class FlashlineRegistryProxy implements com.flashline.registry.openapi.service.v300.FlashlineRegistry {
  private String _endpoint = null;
  private com.flashline.registry.openapi.service.v300.FlashlineRegistry flashlineRegistry = null;
  
  public FlashlineRegistryProxy() {
    _initFlashlineRegistryProxy();
  }
  
  public FlashlineRegistryProxy(String endpoint) {
    _endpoint = endpoint;
    _initFlashlineRegistryProxy();
  }
  
  private void _initFlashlineRegistryProxy() {
    try {
      flashlineRegistry = (new com.flashline.registry.openapi.service.v300.FlashlineRegistryServiceLocator()).getFlashlineRegistry();
      if (flashlineRegistry != null) {
        if (_endpoint != null)
          ((javax.xml.rpc.Stub)flashlineRegistry)._setProperty("javax.xml.rpc.service.endpoint.address", _endpoint);
        else
          _endpoint = (String)((javax.xml.rpc.Stub)flashlineRegistry)._getProperty("javax.xml.rpc.service.endpoint.address");
      }
      
    }
    catch (javax.xml.rpc.ServiceException serviceException) {}
  }
  
  public String getEndpoint() {
    return _endpoint;
  }
  
  public void setEndpoint(String endpoint) {
    _endpoint = endpoint;
    if (flashlineRegistry != null)
      ((javax.xml.rpc.Stub)flashlineRegistry)._setProperty("javax.xml.rpc.service.endpoint.address", _endpoint);
    
  }
  
  public com.flashline.registry.openapi.service.v300.FlashlineRegistry getFlashlineRegistry() {
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry;
  }
  
  public com.flashline.registry.openapi.entity.TabTypeBean[] assetTypeTabsRead(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetTypeId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeTabsRead(pAuthTokenBean, pAssetTypeId);
  }
  
  public void assetTabApprove(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetId, long pTabId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetTabApprove(pAuthTokenBean, pAssetId, pTabId);
  }
  
  public void assetTabUnapprove(com.flashline.registry.openapi.entity.AuthToken pAuthTokeBean, long pAssetId, long pTabId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetTabUnapprove(pAuthTokeBean, pAssetId, pTabId);
  }
  
  public void notificationCreate(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, java.lang.String pTemplateType, java.lang.String[] pRecipients, com.flashline.registry.openapi.entity.NameValue[] pSubstitutions) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.notificationCreate(pAuthTokenBean, pTemplateType, pRecipients, pSubstitutions);
  }
  
  public java.lang.String[] notificationSubstitutionsRead(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, java.lang.String pTemplateType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.notificationSubstitutionsRead(pAuthTokenBean, pTemplateType);
  }
  
  public com.flashline.registry.openapi.entity.ArtifactStoreBean[] artifactStoreQuery(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, com.flashline.registry.openapi.query.ArtifactStoreCriteria pArtifactStoreCritera, boolean pCreateIfMissing) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.artifactStoreQuery(pAuthTokenBean, pArtifactStoreCritera, pCreateIfMissing);
  }
  
  public com.flashline.registry.openapi.entity.AuthToken authTokenCreate(java.lang.String userName, java.lang.String credential) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.authTokenCreate(userName, credential);
  }
  
  public com.flashline.registry.openapi.entity.AuthToken authTokenCreateWithLicense(java.lang.String userName, java.lang.String credential, java.lang.String license) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.authTokenCreateWithLicense(userName, credential, license);
  }
  
  public void authTokenDelete(com.flashline.registry.openapi.entity.AuthToken authToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.authTokenDelete(authToken);
  }
  
  public void authTokenValidate(com.flashline.registry.openapi.entity.AuthToken authToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.authTokenValidate(authToken);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName, java.lang.String pVersion, long pAssetTypeID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetCreate(pAuthToken, pName, pVersion, pAssetTypeID);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetCreateFromXML(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String assetXML) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetCreateFromXML(pAuthToken, assetXML);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetRead(pAuthToken, pId);
  }
  
  public java.lang.String assetReadXml(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadXml(pAuthToken, pId);
  }
  
  public java.lang.String assetReadCustomDataString(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String pPath) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadCustomDataString(pAuthToken, pId, pPath);
  }
  
  public java.lang.String assetReadCustomDataNode(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String pPath) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadCustomDataNode(pAuthToken, pId, pPath);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] assetReadArray(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long[] pIds) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadArray(pAuthToken, pIds);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] assetReadArrayFromSummary(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.AssetSummary[] pAssetSummaries) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadArrayFromSummary(pAuthToken, pAssetSummaries);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Asset pAsset) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdate(pAuthToken, pAsset);
  }
  
  public com.flashline.registry.openapi.entity.SubmissionFileInfo[] assetGetUnacceptedFiles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetGetUnacceptedFiles(pAuthToken, pId);
  }
  
  public void assetAcceptFiles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String[] pFilenames) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetAcceptFiles(pAuthToken, pId, pFilenames);
  }
  
  public void assetDeleteFiles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String[] pFilenames) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetDeleteFiles(pAuthToken, pId, pFilenames);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdateCustomDataString(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String pPath, java.lang.String pValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdateCustomDataString(pAuthToken, pAssetID, pPath, pValue);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdateCustomDataStringArray(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String[] pPath, java.lang.String[] pValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdateCustomDataStringArray(pAuthToken, pAssetID, pPath, pValue);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdateCustomDataNode(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String pPath, java.lang.String pValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdateCustomDataNode(pAuthToken, pAssetID, pPath, pValue);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdateCustomDataNodeFromStringArray(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String[] pPath, java.lang.String[] pValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdateCustomDataNodeFromStringArray(pAuthToken, pAssetID, pPath, pValue);
  }
  
  public void assetUploadFiles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String[] pFilenames) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetUploadFiles(pAuthToken, pAssetID, pFilenames);
  }
  
  public void assetAddRegistrarNote(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String pNotes) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetAddRegistrarNote(pAuthToken, pId, pNotes);
  }
  
  public com.flashline.registry.openapi.entity.LogEntry[] assetReadRegistrarNotes(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadRegistrarNotes(pAuthToken, pId);
  }
  
  public void assetRegister(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetRegister(pAuthToken, pID);
  }
  
  public void assetUnRegister(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetUnRegister(pAuthToken, pID);
  }
  
  public void assetAccept(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetAccept(pAuthToken, pID);
  }
  
  public void assetUnAccept(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetUnAccept(pAuthToken, pID);
  }
  
  public void assetSubmit(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetSubmit(pAuthToken, pID);
  }
  
  public void assetUnSubmit(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetUnSubmit(pAuthToken, pID);
  }
  
  public void assetActivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetActivate(pAuthToken, pAssetID);
  }
  
  public void assetDeactivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetDeactivate(pAuthToken, pAssetID);
  }
  
  public void assetRetire(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetRetire(pAuthToken, pAssetID);
  }
  
  public void assetDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetDelete(pAuthToken, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.TabBean[] assetTabsRead(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTabsRead(pAuthTokenBean, pAssetId);
  }
  
  public com.flashline.registry.openapi.entity.TabBean assetTabRead(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetId, long pTabTypeBeanId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTabRead(pAuthTokenBean, pAssetId, pTabTypeBeanId);
  }
  
  public com.flashline.registry.openapi.entity.AssetSummary[] assetQuerySummary(com.flashline.registry.openapi.entity.AuthToken pAuthtoken, com.flashline.registry.openapi.query.AssetCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetQuerySummary(pAuthtoken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] assetQuery(com.flashline.registry.openapi.entity.AuthToken pAuthtoken, com.flashline.registry.openapi.query.AssetCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetQuery(pAuthtoken, pCriteria);
  }
  
  public int assetQueryCount(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.AssetCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetQueryCount(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.Project[] assetReadAppliedToProjects(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Asset pAsset) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadAppliedToProjects(pAuthToken, pAsset);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] assetReadAppliedPolicies(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetReadAppliedPolicies(pAuthToken, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.Asset assetUpdateAppliedPolicies(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, long[] pAppliedPolicies) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetUpdateAppliedPolicies(pAuthToken, pAssetID, pAppliedPolicies);
  }
  
  public com.flashline.registry.openapi.entity.KeyValuePair assetEvaluate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.AssetCriteria pCriteria, java.lang.String pEvaluationName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetEvaluate(pAuthToken, pCriteria, pEvaluationName);
  }
  
  public java.lang.String assetEvaluateAgainstAllPolicies(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetEvaluateAgainstAllPolicies(pAuthToken, pAssetID);
  }
  
  public java.lang.String assetEvaluateAgainstPolicy(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, long pPolicyID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetEvaluateAgainstPolicy(pAuthToken, pAssetID, pPolicyID);
  }
  
  public void assetApplyToProjects(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String[] pProjectIDs, com.flashline.registry.openapi.entity.Asset pAsset) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetApplyToProjects(pAuthToken, pProjectIDs, pAsset);
  }
  
  public void assetRemoveAppliedToProjects(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String[] pProjectIDs, com.flashline.registry.openapi.entity.Asset pAsset) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetRemoveAppliedToProjects(pAuthToken, pProjectIDs, pAsset);
  }
  
  public java.lang.String repositoryFileTranslator(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.FileInfo pFileInfo) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.repositoryFileTranslator(pAuthToken, pFileInfo);
  }
  
  public com.flashline.registry.openapi.entity.CategorizationType categorizationTypeCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName, java.lang.String pSingularDisplay, java.lang.String pPluralDisplay, boolean pExclusiveAssign, boolean pProjectAssign) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationTypeCreate(pAuthToken, pName, pSingularDisplay, pPluralDisplay, pExclusiveAssign, pProjectAssign);
  }
  
  public com.flashline.registry.openapi.entity.CategorizationType categorizationTypeRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pCategorizationTypeID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationTypeRead(pAuthToken, pCategorizationTypeID);
  }
  
  public com.flashline.registry.openapi.entity.CategorizationType categorizationTypeUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.CategorizationType pType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationTypeUpdate(pAuthToken, pType);
  }
  
  public void categorizationTypeDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.categorizationTypeDelete(pAuthToken, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.CategorizationType[] categorizationTypeQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.CategorizationTypeCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationTypeQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pCategorizationName, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationCreate(pAuthToken, pCategorizationName, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationChildCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pCategorizationName, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType, com.flashline.registry.openapi.entity.Categorization pSuper) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationChildCreate(pAuthToken, pCategorizationName, pCategorizationType, pSuper);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pCategorizationID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationRead(pAuthToken, pCategorizationID);
  }
  
  public com.flashline.registry.openapi.entity.Categorization[] categorizationReadByType(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType, boolean active, boolean fullTree) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationReadByType(pAuthToken, pCategorizationType, active, fullTree);
  }
  
  public com.flashline.registry.openapi.entity.Categorization[] categorizationChildRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType, com.flashline.registry.openapi.entity.Categorization pCategorization, boolean active) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationChildRead(pAuthToken, pCategorizationType, pCategorization, active);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Categorization pCategorization, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationUpdate(pAuthToken, pCategorization, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.Categorization[] categorizationUpdateArray(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Categorization[] pCategorizations, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationUpdateArray(pAuthToken, pCategorizations, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationDeactivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Categorization pCategorization, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationDeactivate(pAuthToken, pCategorization, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.Categorization categorizationReactivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Categorization pCategorization, com.flashline.registry.openapi.entity.CategorizationType pCategorizationType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.categorizationReactivate(pAuthToken, pCategorization, pCategorizationType);
  }
  
  public com.flashline.registry.openapi.entity.Contact contactCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.contactCreate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.Contact contactRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.contactRead(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.Contact contactUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Contact pContact) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.contactUpdate(pAuthToken, pContact);
  }
  
  public void contactDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.contactDelete(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.Contact[] contactQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.ContactCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.contactQuery(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.ExtractionDownload[] extractionCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectId, long[] pAssetIDs) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionCreate(pAuthToken, pProjectId, pAssetIDs);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser[] extractionGetHiddenAssetUsers(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionGetHiddenAssetUsers(pAuthToken, pProjectID);
  }
  
  public com.flashline.registry.openapi.entity.ExtractionDownload[] extractionCreateForUser(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long[] pAssetIDs, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionCreateForUser(pAuthToken, pProjectID, pAssetIDs, pRbacRegistrySecUserBean);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionTentativelyAccept(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionTentativelyAccept(pAuthToken, pExtraction);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionStillEvaluating(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionStillEvaluating(pAuthToken, pExtraction);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionReject(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction, com.flashline.registry.openapi.entity.Categorization pCategorization, java.lang.String pComments) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReject(pAuthToken, pExtraction, pCategorization, pComments);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionUpdateSurvey(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction, com.flashline.registry.openapi.entity.SurveyTaken pSurveyTaken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionUpdateSurvey(pAuthToken, pExtraction, pSurveyTaken);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionUpdateSurveyForUser(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction, com.flashline.registry.openapi.entity.SurveyTaken pSurveyTaken, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionUpdateSurveyForUser(pAuthToken, pExtraction, pSurveyTaken, pRbacRegistrySecUserBean);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pExtractionID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionRead(pAuthToken, pExtractionID);
  }
  
  public com.flashline.registry.openapi.entity.Extraction extractionReadByProjectAndAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadByProjectAndAsset(pAuthToken, pProjectID, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.Extraction[] extractionReadUserExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, boolean pActive) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadUserExtractions(pAuthToken, pActive);
  }
  
  public com.flashline.registry.openapi.entity.Extraction[] extractionReadAssetExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long pAssetID, boolean pActive) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadAssetExtractions(pAuthToken, pProjectID, pAssetID, pActive);
  }
  
  public com.flashline.registry.openapi.entity.Extraction[] extractionReadProjectExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, boolean pActive) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadProjectExtractions(pAuthToken, pProjectID, pActive);
  }
  
  public com.flashline.registry.openapi.entity.ExtractionDownload[] extractionReadExtractionDownloads(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadExtractionDownloads(pAuthToken, pExtraction);
  }
  
  public com.flashline.registry.openapi.entity.FileInfo[] extractionReadFileInfos(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadFileInfos(pAuthToken, pExtraction);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] extractionReadRelatedAssets(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadRelatedAssets(pAuthToken, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.Categorization[] extractionReadRejectionReasons(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadRejectionReasons(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.IExtraction extractionReadExtractionStates(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.extractionReadExtractionStates(pAuthToken);
  }
  
  public void extractionResetDatabase() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.extractionResetDatabase();
  }
  
  public com.flashline.registry.openapi.entity.ProjectAssetValue projectAssetValueReadForUser(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long pAssetID, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectAssetValueReadForUser(pAuthToken, pProjectID, pAssetID, pRbacRegistrySecUserBean);
  }
  
  public com.flashline.registry.openapi.entity.ProjectAssetValue[] projectAssetValueRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectAssetValueRead(pAuthToken, pProjectID, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.ProjectAssetValueSummary projectAssetValueReadSummary(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectAssetValueReadSummary(pAuthToken, pProjectID, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.AssetUsageType[] projectAssetValueReadTypes(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectAssetValueReadTypes(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.ProjectAssetValue projectAssetValueUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ProjectAssetValue pProjectAssetValue, java.lang.String pSelection) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectAssetValueUpdate(pAuthToken, pProjectAssetValue, pSelection);
  }
  
  public com.flashline.registry.openapi.entity.Project projectCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject, com.flashline.registry.openapi.entity.ProjectEntities pProjectEntities) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectCreate(pAuthToken, pProject, pProjectEntities);
  }
  
  public com.flashline.registry.openapi.entity.Project projectRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectRead(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.Project[] projectReadArray(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long[] pIds) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadArray(pAuthToken, pIds);
  }
  
  public com.flashline.registry.openapi.entity.Project[] projectReadArrayFromSummary(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ProjectSummary[] pProjectSummaries) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadArrayFromSummary(pAuthToken, pProjectSummaries);
  }
  
  public com.flashline.registry.openapi.entity.Project projectUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject, com.flashline.registry.openapi.entity.ProjectEntities pProjectEntities) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectUpdate(pAuthToken, pProject, pProjectEntities);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser[] projectReadMembers(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadMembers(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadMemberIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadMemberIDs(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser[] projectReadLeaders(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadLeaders(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadLeaderIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadLeaderIDs(pAuthToken, pProject);
  }
  
  public void projectReassignExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject, com.flashline.registry.openapi.decision.ExtractionReassignmentDecision[] pReassignIDs) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.projectReassignExtractions(pAuthToken, pProject, pReassignIDs);
  }
  
  public void projectReassignUsers(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject, com.flashline.registry.openapi.decision.ExtractionReassignmentDecision[] pReassignIDs) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.projectReassignUsers(pAuthToken, pProject, pReassignIDs);
  }
  
  public com.flashline.registry.openapi.entity.ProjectUserType projectReadUserTypes(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadUserTypes(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.Project[] projectReadParentProjects(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadParentProjects(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadParentProjectIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadParentProjectIDs(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.Project[] projectReadChildProjects(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadChildProjects(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadChildProjectIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadChildProjectIDs(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.Extraction[] projectReadExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadExtractions(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadExtractionAssetIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadExtractionAssetIDs(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.ProjectAsset[] projectReadAssets(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadAssets(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] projectReadPrescribedAssets(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadPrescribedAssets(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.RelatedEntity[] projectReadAppliedComplianceTemplates(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadAppliedComplianceTemplates(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] projectReadProducedAssets(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadProducedAssets(pAuthToken, pProject);
  }
  
  public java.lang.String[] projectReadProducedAssetIDs(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectReadProducedAssetIDs(pAuthToken, pProject);
  }
  
  public com.flashline.registry.openapi.entity.Project[] projectQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.ProjectCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectQuery(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.ProjectSummary[] projectQuerySummary(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.ProjectCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectQuerySummary(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.Results projectValidate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Project pProject, com.flashline.registry.openapi.entity.ProjectEntities pProjectEntities) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.projectValidate(pAuthToken, pProject, pProjectEntities);
  }
  
  public com.flashline.registry.openapi.entity.Department departmentCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName, java.lang.String pDescription) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.departmentCreate(pAuthToken, pName, pDescription);
  }
  
  public com.flashline.registry.openapi.entity.Department departmentRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pKey) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.departmentRead(pAuthToken, pKey);
  }
  
  public com.flashline.registry.openapi.entity.Department departmentUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Department pDepartment) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.departmentUpdate(pAuthToken, pDepartment);
  }
  
  public com.flashline.registry.openapi.entity.Department[] departmentQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.DepartmentCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.APIValidationException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.departmentQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.AcceptableValueList acceptableValueListCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pListName, com.flashline.registry.openapi.entity.AcceptableValue[] pValues) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.acceptableValueListCreate(pAuthToken, pListName, pValues);
  }
  
  public com.flashline.registry.openapi.entity.AcceptableValueList acceptableValueListRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.acceptableValueListRead(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.AcceptableValueList acceptableValueListUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.AcceptableValueList pList) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.acceptableValueListUpdate(pAuthToken, pList);
  }
  
  public com.flashline.registry.openapi.entity.AcceptableValueList[] acceptableValueListQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.AcceptableValueListCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.acceptableValueListQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.AssetType assetTypeCreateClone(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pBaseAssetTypeID, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeCreateClone(pAuthToken, pBaseAssetTypeID, pName);
  }
  
  public com.flashline.registry.openapi.entity.AssetType assetTypeCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeCreate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.AssetType assetTypeCreateComplianceTemplate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeCreateComplianceTemplate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.AssetType assetTypeRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeRead(pAuthToken, pId);
  }
  
  public com.oracle.registry.openapi.entity.EntityArtifactRule[] assetTypeGetEntityArtifactRules(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetTypeId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeGetEntityArtifactRules(pAuthTokenBean, pAssetTypeId);
  }
  
  public com.flashline.registry.openapi.entity.AssetType assetTypeUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.AssetType pAssetType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeUpdate(pAuthToken, pAssetType);
  }
  
  public void assetTypeDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetTypeDelete(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.AssetType[] assetTypeQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.AssetTypeCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeQuery(pAuthToken, pCriteria);
  }
  
  public java.lang.String assetTypeSchemaRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetTypeSchemaRead(pAuthToken, pId);
  }
  
  public java.lang.String configGetWebResourcePath() throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.configGetWebResourcePath();
  }
  
  public void systemSettingsAddBundle(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pXml) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.systemSettingsAddBundle(pAuthToken, pXml);
  }
  
  public com.flashline.registry.openapi.entity.SettingValue[] systemSettingsQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.SystemSettingsCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.systemSettingsQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pUserName, java.lang.String pFirstName, java.lang.String pLastName, java.lang.String pEmail, java.lang.String pPassword, boolean pMustChangePassword, boolean pPasswordNeverExpires, boolean pAssignDefaultRoles) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userCreate(pAuthToken, pUserName, pFirstName, pLastName, pEmail, pPassword, pMustChangePassword, pPasswordNeverExpires, pAssignDefaultRoles);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userRead(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userReadByAuthToken(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userReadByAuthToken(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userUpdate(pAuthToken, pRbacRegistrySecUserBean);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userActivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userActivate(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userDeactivate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userDeactivate(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userLockout(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userLockout(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userUnapprove(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userUnapprove(pAuthToken, pId);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser[] userQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.UserCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userAddRole(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String pRoleName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userAddRole(pAuthToken, pId, pRoleName);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser userRemoveRole(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pId, java.lang.String pRoleName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.userRemoveRole(pAuthToken, pId, pRoleName);
  }
  
  public void unitTestUserResetDatabase() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.unitTestUserResetDatabase();
  }
  
  public java.lang.String[] customAccessSettingNamesGet(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.customAccessSettingNamesGet(pAuthToken, pType);
  }
  
  public java.lang.String[] customAccessSettingDefaultNamesGet(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.customAccessSettingDefaultNamesGet(pAuthToken, pType);
  }
  
  public java.lang.String[] customAccessSettingTypesGet(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.customAccessSettingTypesGet(pAuthToken);
  }
  
  public boolean rbacHasPermission(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pUserID, java.lang.String[] pRoleContextNames, java.lang.String pPermissionName) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.rbacHasPermission(pAuthToken, pUserID, pRoleContextNames, pPermissionName);
  }
  
  public com.flashline.registry.openapi.entity.Role roleCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName, java.lang.String pDesc, boolean pDefaultForNewUser) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.roleCreate(pAuthToken, pName, pDesc, pDefaultForNewUser);
  }
  
  public com.flashline.registry.openapi.entity.Role roleRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.roleRead(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.Role roleUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Role pRoleType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.roleUpdate(pAuthToken, pRoleType);
  }
  
  public void roleDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.roleDelete(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.Role[] roleQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.RoleCriteria pCriteria) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.roleQuery(pAuthToken, pCriteria);
  }
  
  public com.flashline.registry.openapi.entity.RelationshipType relationshipTypeCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.relationshipTypeCreate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.RelationshipType relationshipTypeRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.relationshipTypeRead(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.RelationshipType relationshipTypeUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.RelationshipType pRelationshipType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.relationshipTypeUpdate(pAuthToken, pRelationshipType);
  }
  
  public void relationshipTypeDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.relationshipTypeDelete(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.RelationshipType[] relationshipTypeQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.RelationshipTypeCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.relationshipTypeQuery(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.SurveyTaken surveyTakenRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Extraction pExtraction) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.surveyTakenRead(pAuthToken, pExtraction);
  }
  
  public com.flashline.registry.openapi.entity.Question[] surveyReadQuestions(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.surveyReadQuestions(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.SurveyTaken surveyTakenUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.SurveyTaken pSurveyTaken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.surveyTakenUpdate(pAuthToken, pSurveyTaken);
  }
  
  public com.flashline.registry.openapi.entity.Vendor vendorCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.vendorCreate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.Vendor vendorRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.vendorRead(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.Vendor vendorUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.Vendor pVendor) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.vendorUpdate(pAuthToken, pVendor);
  }
  
  public void vendorDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.vendorDelete(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.Vendor[] vendorQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.VendorCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.vendorQuery(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob[] exportListJobs(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportListJobs(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob exportExecute(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pExportFormat, java.lang.String[] pExportFormatQualifiers, java.lang.String pDesc, java.lang.String pQueryFormat, java.lang.String pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportExecute(pAuthToken, pExportFormat, pExportFormatQualifiers, pDesc, pQueryFormat, pQuery);
  }
  
  public byte[] exportGetAuditB64(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportGetAuditB64(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public void exportGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportGetAuditDIME(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public void exportGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportGetAuditSwA(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public com.flashline.registry.openapi.entity.AuditMsg exportGetLatestAuditMsg(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportGetLatestAuditMsg(pAuthToken, pJobBean);
  }
  
  public byte[] importGetAuditB64(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.importGetAuditB64(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public void importGetAuditDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.importGetAuditDIME(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public void importGetAuditSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean, java.lang.String pAuditFormat) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.importGetAuditSwA(pAuthToken, pJobBean, pAuditFormat);
  }
  
  public com.flashline.registry.openapi.entity.AuditMsg importGetLatestAuditMsg(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJobBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.importGetLatestAuditMsg(pAuthToken, pJobBean);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob exportStatus(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportStatus(pAuthToken, pJob);
  }
  
  public void exportKill(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportKill(pAuthToken, pJob);
  }
  
  public byte[] exportGetResultsB64(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.exportGetResultsB64(pAuthToken, pJob);
  }
  
  public void exportGetResultsDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportGetResultsDIME(pAuthToken, pJob);
  }
  
  public void exportGetResultsSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportGetResultsSwA(pAuthToken, pJob);
  }
  
  public void exportCleanup(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportCleanup(pAuthToken, pJob);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob[] importListJobs(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.importListJobs(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob importExecute(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pImportFormat, java.lang.String[] pImportFormatQualifiers, java.lang.String pDesc, byte[] pPayload) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.importExecute(pAuthToken, pImportFormat, pImportFormatQualifiers, pDesc, pPayload);
  }
  
  public com.flashline.registry.openapi.entity.ImpExpJob importStatus(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.importStatus(pAuthToken, pJob);
  }
  
  public void importKill(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.importKill(pAuthToken, pJob);
  }
  
  public void importCheckPermission(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.importCheckPermission(pAuthToken);
  }
  
  public void exportCheckPermission(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.exportCheckPermission(pAuthToken);
  }
  
  public void importCleanup(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.ImpExpJob pJob) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.importCleanup(pAuthToken, pJob);
  }
  
  public void testClearCache(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pCacheName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testClearCache(pAuthToken, pCacheName);
  }
  
  public void testUpdateAssetDate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, java.lang.String pDateField, java.util.Calendar pNewDate) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testUpdateAssetDate(pAuthToken, pAssetID, pDateField, pNewDate);
  }
  
  public void testUpdateTabStatus(com.flashline.registry.openapi.entity.AuthToken pAuthToken, boolean pApproved, long pUserID, java.lang.String pTab, long pAssetID, java.util.Calendar pDate) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testUpdateTabStatus(pAuthToken, pApproved, pUserID, pTab, pAssetID, pDate);
  }
  
  public void testCreateCustomAccessSetting(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pType, java.lang.String pRoleContextName, boolean pIsDefault) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testCreateCustomAccessSetting(pAuthToken, pType, pRoleContextName, pIsDefault);
  }
  
  public long getAssetMaxID() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.getAssetMaxID();
  }
  
  public void testThrowOpenAPIException() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testThrowOpenAPIException();
  }
  
  public void testSetSetting(java.lang.String pSettingName, java.lang.String pSettingValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testSetSetting(pSettingName, pSettingValue);
  }
  
  public java.lang.String testGetSettingValue(java.lang.String pSettingName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testGetSettingValue(pSettingName);
  }
  
  public void testSetProperty(java.lang.String pPropName, java.lang.String pPropValue) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testSetProperty(pPropName, pPropValue);
  }
  
  public void testDeleteAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testDeleteAsset(pAuthToken, pAssetId);
  }
  
  public void testDeleteUser(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pUserId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testDeleteUser(pAuthToken, pUserId);
  }
  
  public void testDeleteProject(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testDeleteProject(pAuthToken, pProjectId);
  }
  
  public void testDeleteAssetType(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testDeleteAssetType(pAuthToken, pAssetId);
  }
  
  public void testRestartJobMonitor() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRestartJobMonitor();
  }
  
  public void testThrowImportExportException(boolean pImpExp) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException, com.flashline.registry.openapi.base.ImportExportException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testThrowImportExportException(pImpExp);
  }
  
  public boolean testGetLicenseState() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testGetLicenseState();
  }
  
  public java.lang.String testDetermineDBPlatform() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testDetermineDBPlatform();
  }
  
  public void testSetLicenseState(boolean pLicensed) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testSetLicenseState(pLicensed);
  }
  
  public void testAcceptableValueListDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testAcceptableValueListDelete(pAuthToken, pID);
  }
  
  public void testLogMessage(java.lang.String pMessage) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testLogMessage(pMessage);
  }
  
  public void testExtractionResetDatabaseForProject(long pProjectID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testExtractionResetDatabaseForProject(pProjectID);
  }
  
  public void testUpdateViewAssetSetting(boolean pRemove) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testUpdateViewAssetSetting(pRemove);
  }
  
  public void testCleanupNonRunningJobs() throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testCleanupNonRunningJobs();
  }
  
  public void testUpdateUserRole(long pUserID, boolean pRemove) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testUpdateUserRole(pUserID, pRemove);
  }
  
  public void testUpdateProjectAdminRole(long pUserID, boolean pRemove) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testUpdateProjectAdminRole(pUserID, pRemove);
  }
  
  public void testClearDatabase() throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testClearDatabase();
  }
  
  public void sfidAddToAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.SFIDInfo pSFID, long assetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidAddToAsset(pAuthToken, pSFID, assetID);
  }
  
  public void sfidRemoveAllFromAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long assetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidRemoveAllFromAsset(pAuthToken, assetID);
  }
  
  public void sfidUpdateAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.SFIDInfo[] pSFIDs, long assetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidUpdateAsset(pAuthToken, pSFIDs, assetID);
  }
  
  public java.lang.String[] sfidReadValuesByProject(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidReadValuesByProject(pAuthToken, projectid);
  }
  
  public com.flashline.registry.openapi.entity.SFIDInfo[] sfidQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.SFIDCriteria pCrit) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidQuery(pAuthToken, pCrit);
  }
  
  public com.flashline.registry.openapi.entity.SFIDCandidate[] sfidCandidateQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.SFIDCriteria pCrit) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidCandidateQuery(pAuthToken, pCrit);
  }
  
  public com.flashline.registry.openapi.entity.SFIDInfo[] sfidGenerate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, int pMethod) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidGenerate(pAuthToken, pMethod);
  }
  
  public com.flashline.registry.openapi.entity.SFIDCandidate[] sfidCandidateSubmit(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.SFIDCandidate[] pCandidates) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidCandidateSubmit(pAuthToken, pCandidates);
  }
  
  public java.lang.String[] sfidReadValuesForAsset(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long assetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidReadValuesForAsset(pAuthToken, assetID);
  }
  
  public void sfidRegisterExtractionBySFIDValue(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid, java.lang.String pSFID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidRegisterExtractionBySFIDValue(pAuthToken, projectid, pSFID);
  }
  
  public void sfidRegisterExtractionBySFIDValues(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid, java.lang.String[] pSFIDs) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidRegisterExtractionBySFIDValues(pAuthToken, projectid, pSFIDs);
  }
  
  public com.flashline.registry.openapi.entity.AssetSummary[] sfidRegisterExtractionBySFIDCandidates(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid, com.flashline.registry.openapi.entity.SFIDCandidate[] pSFIDCandidates) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidRegisterExtractionBySFIDCandidates(pAuthToken, projectid, pSFIDCandidates);
  }
  
  public void sfidRegisterExtractionBySFIDCandidatesLite(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid, com.flashline.registry.openapi.entity.SFIDCandidate[] pSFIDCandidates) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidRegisterExtractionBySFIDCandidatesLite(pAuthToken, projectid, pSFIDCandidates);
  }
  
  public void sfidRegisterExtractions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pProjectID, com.flashline.registry.openapi.entity.SFIDCandidate[] pSFIDCandidates, boolean pHarvest) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.sfidRegisterExtractions(pAuthToken, pProjectID, pSFIDCandidates, pHarvest);
  }
  
  public com.flashline.registry.openapi.entity.AssetSummary[] sfidRegisterExtractionBySFIDValuesResults(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long projectid, java.lang.String[] pSFIDs) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.sfidRegisterExtractionBySFIDValuesResults(pAuthToken, projectid, pSFIDs);
  }
  
  public com.flashline.registry.openapi.entity.ReuseDTO reuseDTORead() throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.reuseDTORead();
  }
  
  public void assetMetadataCreateDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataCreateDIME(pAuthToken, pMetadataEntrySummary);
  }
  
  public void assetMetadataCreateSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataCreateSwA(pAuthToken, pMetadataEntrySummary);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary[] assetMetadataRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetMetadataRead(pAuthToken, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary[] assetMetadataReadDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetMetadataReadDIME(pAuthToken, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary[] assetMetadataReadSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.assetMetadataReadSwA(pAuthToken, pAssetID);
  }
  
  public void assetMetadataUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataUpdate(pAuthToken, pMetadataEntrySummary);
  }
  
  public void assetMetadataUpdateDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataUpdateDIME(pAuthToken, pMetadataEntrySummary);
  }
  
  public void assetMetadataUpdateSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAssetID, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataUpdateSwA(pAuthToken, pAssetID, pMetadataEntrySummary);
  }
  
  public void assetMetadataEntryDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pMetadataEntryID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataEntryDelete(pAuthToken, pMetadataEntryID);
  }
  
  public void assetMetadataAccept(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.assetMetadataAccept(pAuthToken, pMetadataEntrySummary);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntryTypeSummary metadataEntryTypeCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pName) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryTypeCreate(pAuthToken, pName);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntryTypeSummary metadataEntryTypeRead(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryTypeRead(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntryTypeSummary metadataEntryTypeUpdate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntryTypeSummary pMetadataEntryType) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryTypeUpdate(pAuthToken, pMetadataEntryType);
  }
  
  public void metadataEntryTypeDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.metadataEntryTypeDelete(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntryTypeSummary[] metadataEntryTypeQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.MetadataEntryTypeCriteria pQuery) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryTypeQuery(pAuthToken, pQuery);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryCreateDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryCreateDIME(pAuthToken, pMetadataEntrySummary);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryCreateSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryCreateSwA(pAuthToken, pMetadataEntrySummary);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryReadDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryReadDIME(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryReadDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.EntityUUID pEntityUUID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryReadDIME(pAuthToken, pEntityUUID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryReadSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryReadSwA(pAuthToken, pID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryReadSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.EntityUUID pEntityUUID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryReadSwA(pAuthToken, pEntityUUID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryUpdateDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryUpdateDIME(pAuthToken, pMetadataEntrySummary);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary metadataEntryUpdateSwA(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.MetadataEntrySummary pMetadataEntrySummary) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryUpdateSwA(pAuthToken, pMetadataEntrySummary);
  }
  
  public void metadataEntryDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.entity.EntityUUID pEntityUUID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.metadataEntryDelete(pAuthToken, pEntityUUID);
  }
  
  public com.flashline.registry.openapi.entity.MetadataEntrySummary[] metadataEntryQuery(com.flashline.registry.openapi.entity.AuthToken pAuthToken, com.flashline.registry.openapi.query.MetadataEntryCriteria pQuery) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.metadataEntryQuery(pAuthToken, pQuery);
  }
  
  public void testCasDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pCasName) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testCasDelete(pAuthToken, pCasName);
  }
  
  public void testCasCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pCasName, java.lang.String pCasType) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testCasCreate(pAuthToken, pCasName, pCasType);
  }
  
  public void testRoleContextAddRole(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextAddRole(pAuthToken, pRoleContextName, pRoleName, pRoleOperator);
  }
  
  public void testRoleContextSetPermission(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator, com.flashline.registry.openapi.entity.PermissionValue pPermissionValueBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextSetPermission(pAuthToken, pRoleContextName, pRoleName, pRoleOperator, pPermissionValueBean);
  }
  
  public void testRoleContextSetPermissions(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator, com.flashline.registry.openapi.entity.PermissionValue[] pPermssionValueBeans) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextSetPermissions(pAuthToken, pRoleContextName, pRoleName, pRoleOperator, pPermssionValueBeans);
  }
  
  public void testRoleContextApplySecuritySettingToExisting(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextApplySecuritySettingToExisting(pAuthToken, pRoleContextName);
  }
  
  public java.lang.String[] testRoleContextGetAllRoles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testRoleContextGetAllRoles(pAuthToken, pRoleContextName);
  }
  
  public java.lang.String testRoleContextGetPermissionFromRole(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pPermissionName, java.lang.String pRoleName, java.lang.String pRoleOperator) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testRoleContextGetPermissionFromRole(pAuthToken, pRoleContextName, pPermissionName, pRoleName, pRoleOperator);
  }
  
  public void testRoleContextClearRoles(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextClearRoles(pAuthToken, pRoleContextName);
  }
  
  public void testRoleContextRemoveRole(com.flashline.registry.openapi.entity.AuthToken pAuthToken, java.lang.String pRoleContextName, java.lang.String pRoleName, java.lang.String pRoleOperator) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.testRoleContextRemoveRole(pAuthToken, pRoleContextName, pRoleName, pRoleOperator);
  }
  
  public int testDoSQL(java.lang.String pSQL) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testDoSQL(pSQL);
  }
  
  public boolean testHasSufficientAssets() throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testHasSufficientAssets();
  }
  
  public java.lang.String[] testDoSimpleQuery(java.lang.String[] pArgs, java.lang.String pColumnName, java.lang.String pQuery) throws java.rmi.RemoteException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.testDoSimpleQuery(pArgs, pColumnName, pQuery);
  }
  
  public void subscriptionCreate(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long[] pAssetIDs, boolean pFailOnAnyError) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.subscriptionCreate(pAuthToken, pAssetIDs, pFailOnAnyError);
  }
  
  public void subscriptionDelete(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long[] pAssetIDs) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.subscriptionDelete(pAuthToken, pAssetIDs);
  }
  
  public long[] subscriptionReadSubscribedAssets(com.flashline.registry.openapi.entity.AuthToken pAuthToken) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.subscriptionReadSubscribedAssets(pAuthToken);
  }
  
  public com.flashline.registry.openapi.entity.RegistryUser[] subscriptionReadUsersSubscribedToAsset(com.flashline.registry.openapi.entity.AuthToken pAuthTokenBean, long pAssetID) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.subscriptionReadUsersSubscribedToAsset(pAuthTokenBean, pAssetID);
  }
  
  public com.flashline.registry.openapi.entity.Asset[] retrieveRootArtifacts(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.retrieveRootArtifacts(pAuthToken, pAbstractAssetId);
  }
  
  public com.flashline.registry.openapi.entity.Asset retrieveLatestRootArtifact(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.retrieveLatestRootArtifact(pAuthToken, pAbstractAssetId);
  }
  
  public void retrieveArtifactCollectionAsDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveArtifactCollectionAsDIME(pAuthToken, pAbstractAssetId, pArtifactRootId);
  }
  
  public void retrieveAndRecordUsageOfArtifactCollectionAsDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveAndRecordUsageOfArtifactCollectionAsDIME(pAuthToken, pAbstractAssetId, pArtifactRootId, pProjectId);
  }
  
  public void retrieveAndRecordUsageOfArtifactCollectionAsDIME(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveAndRecordUsageOfArtifactCollectionAsDIME(pAuthToken, pAbstractAssetId, pArtifactRootId, pProjectId, pRbacRegistrySecUserBean);
  }
  
  public void retrieveArtifactCollectionAsSwa(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveArtifactCollectionAsSwa(pAuthToken, pAbstractAssetId, pArtifactRootId);
  }
  
  public void retrieveAndRecordUsageOfArtifactCollectionAsSwa(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveAndRecordUsageOfArtifactCollectionAsSwa(pAuthToken, pAbstractAssetId, pArtifactRootId, pProjectId);
  }
  
  public void retrieveAndRecordUsageOfArtifactCollectionAsSwa(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, long pArtifactRootId, long pProjectId, com.flashline.registry.openapi.entity.RegistryUser pRbacRegistrySecUserBean) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    flashlineRegistry.retrieveAndRecordUsageOfArtifactCollectionAsSwa(pAuthToken, pAbstractAssetId, pArtifactRootId, pProjectId, pRbacRegistrySecUserBean);
  }
  
  public com.flashline.registry.openapi.entity.FileInfo[] getLatestArtifacts(com.flashline.registry.openapi.entity.AuthToken pAuthToken, long pAbstractAssetId, boolean pIsService) throws java.rmi.RemoteException, com.flashline.registry.openapi.base.OpenAPIException{
    if (flashlineRegistry == null)
      _initFlashlineRegistryProxy();
    return flashlineRegistry.getLatestArtifacts(pAuthToken, pAbstractAssetId, pIsService);
  }
  
  
}